import re

# 读取文件内容
with open('d:/未知/yolo_apply/video_processing/video_processor.py', 'r', encoding='utf-8') as f:
    content = f.read()

# 使用正则表达式查找_process_loop方法的开始和结束
method_start_match = re.search(r'def _process_loop\(self\):', content)
if method_start_match:
    method_start = method_start_match.start()
    
    # 计算方法的缩进级别
    lines = content[:method_start].split('\n')
    last_line = lines[-1]
    method_indent = len(last_line) - len(last_line.lstrip())
    
    # 查找方法的结束位置（下一个同级别或更低级别的def）
    lines_after = content[method_start:].split('\n')
    method_lines = []
    in_method = True
    brace_level = 0
    
    for i, line in enumerate(lines_after):
        stripped = line.lstrip()
        indent = len(line) - len(stripped)
        
        # 检查是否是新的方法定义且缩进级别等于或低于_process_loop
        if stripped.startswith('def ') and indent <= method_indent and i > 10:
            method_end = method_start + sum(len(l) + 1 for l in lines_after[:i]) - 1
            break
        
        method_lines.append(line)
    else:
        # 如果没有找到下一个方法，就到文件末尾
        method_end = len(content)
    
    # 提取原始方法内容
    original_method = '\n'.join(method_lines)
    
    # 修复方法结构 - 确保有正确的try-except-finally
    # 这里我们将创建一个简化版的修复
    print("找到_process_loop方法")
    print(f"方法开始位置: {method_start}")
    print(f"方法缩进级别: {method_indent}")
    
    # 尝试查找try和finally的位置
    try_pos = original_method.find('try:')
    if try_pos != -1:
        print(f"找到try语句在位置: {try_pos}")
    
    finally_pos = original_method.find('finally:')
    if finally_pos != -1:
        print(f"找到finally语句在位置: {finally_pos}")
    
    # 输出方法的一部分用于调试
    print("\n方法前500字符:")
    print(original_method[:500])
    print("\n方法最后500字符:")
    print(original_method[-500:])
    
    # 创建修复版本
    # 这里我们只修复缩进问题，保持原始逻辑
    # 我们会保留except和finally块，但确保它们与try块匹配
    
    # 简单的修复方法：重新构建整个方法结构
    indent = ' ' * method_indent
    inner_indent = ' ' * (method_indent + 4)
    
    # 提取方法体内容（不包括方法定义和异常处理）
    body_start = original_method.find('def _process_loop(self):') + len('def _process_loop(self):')
    body_content = original_method[body_start:]
    
    # 查找第一个try块
    first_try_pos = body_content.find('try:')
    if first_try_pos != -1:
        body_content_before_try = body_content[:first_try_pos]
        body_content_after_try = body_content[first_try_pos:]
        
        # 检查是否已经有except和finally
        has_except = 'except' in body_content_after_try
        has_finally = 'finally' in body_content_after_try
        
        # 创建修复后的方法
        fixed_method = f"{indent}def _process_loop(self):\n"
        fixed_method += body_content_before_try
        fixed_method += "\n"
        fixed_method += f"{inner_indent}try:\n"
        
        # 这里我们无法完全重建内部内容，但我们可以确保结构正确
        # 实际的修复应该更复杂，但这是一个起点
        
        print("\n方法结构分析完成，准备进行修复")
        
        # 写入临时修复方案
        with open('d:/未知/yolo_apply/fixed_process_loop.txt', 'w', encoding='utf-8') as f:
            f.write(fixed_method)
            f.write("\n\n")
            f.write(original_method)
else:
    print("未找到_process_loop方法")